import 'package:get/get.dart';

import './base_repository.dart';
import '../providers/auth_provider.dart';
import '../models/user_model.dart';
import '../../services/storage/local_storage_service.dart';
import '../../services/storage/secure_storage_service.dart'; // 用于存储Token

/// 认证仓库
/// 负责封装认证相关的业务逻辑，如登录、登出、Token管理
class AuthRepository extends BaseRepository {
  // 注入依赖
  final AuthProvider _authProvider = Get.find<AuthProvider>();
  final SecureStorageService _secureStorage = Get.find<SecureStorageService>(); // 使用安全存储

  // 定义存储 Token 的 Key
  static const String _accessTokenKey = 'access_token';
  static const String _refreshTokenKey = 'refresh_token';
  static const String _userJsonKey = 'current_user';

  /// 用户登录
  /// 返回 UserModel 如果成功，否则抛出异常
  Future<UserModel> login(String email, String password) async {
    final response = await _authProvider.login(email, password);

    if (response.isSuccess && response.data != null) {
      final tokenData = response.data!;
      final accessToken = tokenData['accessToken'] as String?;
      final refreshToken = tokenData['refreshToken'] as String?;
      final userData = tokenData['user'] as Map<String, dynamic>?;

      if (accessToken != null && userData != null) {
        // 存储 Token
        await _saveTokens(accessToken, refreshToken);
        
        // 解析并存储用户信息
        final user = UserModel.fromJson(userData);
        await _saveCurrentUser(user);
        
        return user;
      } else {
        throw Exception('登录响应数据无效');
      }
    } else {
      throw Exception(response.message); // 抛出 API 返回的错误信息
    }
  }
  
  /// 用户注册
  /// 返回 UserModel 如果成功，否则抛出异常
  Future<UserModel> register(String name, String email, String password) async {
     final response = await _authProvider.register(name, email, password);
     if (response.isSuccess && response.data != null) {
       // 注册成功通常不直接返回 Token，可能需要用户重新登录
       // 这里直接返回用户信息
       return response.data!;
     } else {
       throw Exception(response.message);
     }
  }
  
  /// 发送密码重置邮件
  Future<void> sendPasswordResetEmail(String email) async {
    final response = await _authProvider.sendPasswordResetEmail(email);
    if (!response.isSuccess) {
      throw Exception(response.message);
    }
  }

  /// 退出登录
  Future<void> logout() async {
    // 清除本地存储的用户信息和 Token
    await _clearAuthData();
    
    // (可选) 调用 API 使 Token 失效
    // final token = await getAccessToken();
    // if (token != null) {
    //   try {
    //     await _authProvider.logout(token);
    //   } catch (e) {
    //     // 忽略登出 API 的错误
    //   }
    // }
  }

  /// 获取当前登录的用户信息
  Future<UserModel?> getCurrentUser() async {
    final userJson = await storageService.read<Map<String, dynamic>>(_userJsonKey);
    if (userJson != null) {
      try {
        return UserModel.fromJson(userJson);
      } catch (e) {
        // 解析失败，清除无效数据
        await _clearAuthData();
        return null;
      }
    }
    return null;
  }

  /// 获取访问 Token
  Future<String?> getAccessToken() async {
    return await _secureStorage.read(_accessTokenKey);
  }

  /// 获取刷新 Token
  Future<String?> getRefreshToken() async {
    return await _secureStorage.read(_refreshTokenKey);
  }

  /// 检查用户是否已登录
  Future<bool> isLoggedIn() async {
    final token = await getAccessToken();
    // 可以增加 Token 有效性验证逻辑
    return token != null;
  }
  
  /// 尝试刷新 Token (示例)
  Future<bool> refreshAuthToken() async {
    final refreshToken = await getRefreshToken();
    if (refreshToken == null) return false;
    
    try {
      final response = await _authProvider.refreshToken(refreshToken);
      if (response.isSuccess && response.data != null) {
        final newAccessToken = response.data!;
        // 可能也需要更新 refreshToken
        await _saveTokens(newAccessToken, null); // 只更新 access token
        return true;
      }
      return false;
    } catch (e) {
      // 刷新失败，可能需要引导用户重新登录
      await logout(); // 刷新失败时登出
      return false;
    }
  }

  /// 保存 Tokens
  Future<void> _saveTokens(String accessToken, String? refreshToken) async {
    await _secureStorage.write(_accessTokenKey, accessToken);
    if (refreshToken != null) {
      await _secureStorage.write(_refreshTokenKey, refreshToken);
    }
  }

  /// 保存当前用户信息到本地存储
  Future<void> _saveCurrentUser(UserModel user) async {
    await storageService.write(_userJsonKey, user.toJson());
  }

  /// 清除认证相关数据
  Future<void> _clearAuthData() async {
    await _secureStorage.delete(_accessTokenKey);
    await _secureStorage.delete(_refreshTokenKey);
    await storageService.remove(_userJsonKey);
  }
} 